Method and device for adaptation of functions for controlling operating sequences

ABSTRACT

A method and a device for adaptation of functions for controlling operating sequences, the functions accessing at least one global variable of at least one program for control and this global variable being assigned address information which is located in at least one memory device, this address information of the global variables being loaded by at least one load instruction out of the memory device, wherein the address information of the global variable of the load instruction is replaced.

FIELD OF THE INVENTION

The present invention is directed to a method and device for adaptationof functions for controlling operating sequences, in particular in amotor vehicle. The present invention is also directed to a correspondingcontrol unit and a corresponding computer for function development andthe associated computer program as well as the corresponding computerprogram product.

BACKGROUND INFORMATION

In function development of control unit software, in particular inautomotive control units for controlling the engine, brakes,transmission, etc., the bypass application is a rapid prototyping methodfor developing and testing new control unit functions. However, suchdevelopment of functions is also possible with all other control unitapplications, e.g., in the field of automation and machine tools.

Two applications of external control unit bypass, as described in GermanPatent Application No. DE 101 06 504 A1, for example, and of internalcontrol unit bypass, as described in German Patent Application No. DE102 286 10 A1, for example, may be used as development methods here.

German Patent Application No. DE 101 06 504 A1 describes a method and anemulation device for emulating control functions and/or regulatingfunctions of a control unit or regulating unit of a motor vehicle inparticular. For emulation, the functions are transferred to an externalemulation computer, a data link being established via a softwareinterface of the emulation computer and a software interface of thecontrol unit/regulating unit before the start of emulation. To greatlyaccelerate the development and programming of new control/regulatingfunctions of the control unit/regulating unit, the software interfacesconfigured for emulation of different control/regulating functionsbefore the start of emulation without any change in software.

German Patent Application No. DE 102 286 10 A1 describes a method and adevice for testing a control program by using at least one bypassfunction in which the control program is executed together with the atleast one bypass function on an electric computing unit. The bypassfunctions are coupled to preselected interfaces via dynamic links.

Independently of these two methods and devices, interventions in thecontrol unit software are necessary for applicability. Suchinterventions are referred to with the term bypass breakpoint orsoftware breakpoint. A bypass breakpoint, i.e., software breakpoint,describes exactly the location in a software function where the contentof a control unit variable is not described by the software program butinstead is described via detours, e.g., via a bypass software function.Software breakpoints are highly individual and in the normal case arenot part of a control unit software program because memory resources areused for this.

If a function developer requires a control unit program having softwarebreakpoints, these are incorporated into a program version only afterthe development department has been commissioned. For this purpose, thesoftware development manually modifies the source code of thecorresponding function and, by running a compiler and link, creates anew control unit program which is used explicitly for the prototypingapplication.

A disadvantage of the conventional method and device includes the longrunning time until availability of the rapid prototyping programversion. An important factor here is the high technical andadministrative cost for the specification and implementation of thesoftware interventions.

According to the information currently available, a comparable method isbased on the idea of replacing only the store instructions (write accessto a control unit variable) via jump instructions to a subfunction.However, in microcontrollers having a mixed instruction set (16/32-bitCPU instructions), the store instructions may already be 16 bits becauseaddressing is performed indirectly via address registers. These 16-bitinstructions cannot be used to call a subfunction because a directaddress-oriented call of a subfunction requires a 32-bit jumpinstruction. Therefore, the conventional method is usable only to alimited extent and may be used only with microprocessors having a pure32-bit instruction set. In other words, when the store instruction has afixed bit width, flexibility with regard to the function development isgreatly restricted here. This is also true when a certain storeinstruction must not be manipulated at all for other reasons, so thatpopulating in this way via a jump instruction to a subfunction is thennot possible at all.

SUMMARY

An object of the present invention is to introduce software breakpointswithout source code changes into an existing software program and toovercome the aforementioned problems of the related art.

The present invention relates to a method and a device for adaptation offunctions for controlling operating sequences, preferably in motorvehicles, where the functions access at least one global variable of atleast one program for control and this global variable is assignedaddress information which is present in at least one memory device, thisaddress information of the global variables being loaded out of thememory device by at least one load instruction and this addressinformation of the global variable of the load instruction beingadvantageously replaced.

An initial address of the function is advantageously determined from theaddress information, the function then being expandable or replaceableby additional functions so that the functions for controlling operatingsequences are replaced and/or expanded by replacing the addressinformation with additional functions.

The present invention expediently uses “dynamic hooks” of softwarebreakpoints without any changes in source code. The method described andthe corresponding device for accomplishing this modify the addressinformation of load instructions, modify the function calls and insertnew program codes. These modifications are performed on an existingsoftware program version, e.g., on the basis of specific HEX codemodifications.

It is also advantageous that the address information of the globalvariable is replaced by the address information of a pointer variable,the address information of the pointer variable being in a reservedmemory area, in particular of the memory device in the control unit.

In addition to the modification with respect to the load instructions,in one embodiment a store instruction is advantageously manipulated ontothe global variable by replacing the store instruction with a jumpinstruction. The functions for controlling the operating sequences areexpediently replaced and/or expanded by replacing the store instructionwith the jump instruction through additional functions.

The present invention further includes a control unit containing such adevice, and along with a computer program suitable for execution of sucha method. This computer program is executed on a computer, in particularan application control unit system according to the present invention oran application PC. The computer program according to the presentinvention may be stored on any machine-readable medium. Such acomputer-readable data medium or machine-readable medium may be inparticular a diskette, a CD-ROM, a DVD, a memory stick or any otherportable memory medium. Likewise, memory media such as ROM, PROM, EPROM,EEPROM or flash memories and volatile RAM memories, etc., are alsopossible for storage. The choice of the memory medium, i.e., themachine-readable medium, is thus not to be regarded as restrictive withrespect to the computer program product as the object of the presentinvention.

Using the present invention, the various rapid prototyping methods,software test methods and data calibration methods are rendered morerapidly usable and more flexible in handling.

Thus, the software breakpoints are implemented without tying up softwaredevelopment capacity. This results in a lower technical andadministrative complexity on the whole and therefore reduces costs.

At the same time, microprocessor types having a mixed set of 16/32-bitCPU instructions, for example, may be supported.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention is explained in greater detail below on the basisof the figures.

FIG. 1 shows a system or a device according to an example embodiment ofthe present invention for adapting the functions.

FIG. 2 shows the sequence for determining the breakpoints or thesoftware breakpoints in the program.

FIG. 3 shows an overview and selection of various methods formodification of the load instructions and/or the store instructions.

FIG. 4 shows a program diagram for a first and preferred modificationmethod of the load instruction.

FIG. 5 shows a program diagram for a second modification method of thestore instruction.

FIG. 6 shows a program diagram for a third modification method of thestore instruction.

FIG. 7 shows a program diagram for a fourth modification method of thestore instruction.

FIG. 8 shows a schematic diagram for adapting the calls of the functionsfor controlling the operating sequences.

FIG. 9 shows the hook function for tying in the additional functions.

FIG. 10 shows a schematic diagram of the memory segments in the memorymeans with reference to the hook function.

FIG. 11 shows in greater detail a complete development process accordingto the present invention.

DETAILED DESCRIPTION OF EXAMPLE EMBODIMENTS

FIG. 1 shows a schematic diagram of an application arrangement having acontrol unit 100 and an application system 101, which are connected tointerfaces 103 and 104 via a link 102. This link 102 may be designed tobe wired or wireless. A microprocessor 105 is shown in particular havinga mixed instruction set. Memory device 106 includes an address register108, a data register 107 and a memory area for the at least one programto be adapted with regard to functions. The control device forimplementing the present invention may be contained in the applicationsystem and/or represented by it or designed using the microprocessoritself. Likewise, a memory device for implementation of the presentinvention may also be situated outside the control unit, in particularin the application system. The present invention is implementable usingthe device shown here.

Although the functions may be adapted using an external bypass, theadvantageous embodiment is to perform the adaptations internally in sucha way that they are tied into the program run and therefore there aredynamic hooks for software interventions without any source codechanges.

In accordance with an example embodiment, the address information ofload instructions is modified, the content of store instructions ismodified, the address information of function is modified and newprogram codes are added. These changes are implemented here in theexemplary embodiment on an existing software program version on thebasis of targeted hex code modifications.

The various components with regard to the object “dynamic softwarebreakpoint” according to the present invention being explained beloware:

-   -   Determination of the program points    -   Modification of the program points including modification of the        load/store instructions and modification of the function calls    -   Creation of additional program code    -   Tying in the software breakpoint code    -   Segmenting the memory areas and    -   Development process for creation of the program code.

The method described below is based on the use of microcontrollershaving a mixed instruction set, in particular 16/32-bit CPUinstructions. For example, the TriCore TC17xx microcontroller(RISC/DSP/CPU) from Infineon is the example used here; it is a componentof a control unit for controlling operating sequences, in particular ina motor vehicle, e.g., for engine control or for controlling thesteering, transmission, brakes, etc.

However, this method may also be used with microprocessors having anon-mixed instruction set, in particular in pure 32-bit microprocessors(RISC processors, e.g., PowerPC/MPC5xx).

In this method, it is assumed that the code generator of the compilerarranges the machine instructions sequentially. This is understood torefer to the sequential arrangement of instructions for loading addressinformation of an indirectly addressed control unit variable, forexample, into the corresponding address registers. In contrast, in thecase of a directly addressed variable, the address information is in theinstruction itself. This is the case with most compilers.

Determination of the Program Points (FIG. 2)

The starting point for this is a control unit software program which isavailable in the form of a hex code file, for example. Additional filesmay include a data description file (e.g., ASAP) and a linker file(e.g., ELF binary) which supply information about control unit variablesand control unit functions.

Using a disassembler software program (e.g., a Windows softwareprogram), the hex code file is disassembled. The corresponding addressesof the control unit variables to be bypassed are taken from the datadescription file or from a reference databank created for the method.

The disassembler program created according to the present invention,e.g., a Windows software program, seeks the corresponding accessinstructions to the control unit variables (load/store instructions) inthe disassembled program code with the assistance of the addressinformation of these variables being sought, which affect the content ofvariables.

This disassembler program as a Windows software program is a simulationprogram which checks the register contents after each assemblerinstruction. If a store instruction is localized and the content of theloaded address register corresponds to the address value of the controlunit being sought or if the memory destination of the store instructioncorresponds to the variable address, then this is a source where thecontent of the control unit variables is modified.

The manner in which the program code is modified at the source dependson the particular type of addressing of the control unit variables.

This is depicted in FIG. 2, which shows control unit program code 201and software function 202. Arrows 203 symbolize the method describedhere for determining the store instructions. Store instruction 204 of avariable access is shown in such a way that in the case of directaddressing, the memory destination of the store instruction is the RAMaddress, and in the case of indirect addressing, the content of theaddress register corresponds to the RAM address, so the loadinstructions may then be determined. Arrows 205 represent the methoddescribed here for determining the load instructions. Load instructions206 are for loading the variable addresses, specifically the globalvariables.

Modification of the Program Points (FIGS. 3 through 8)

First, the load instruction sources and/or the store instruction sourcesare localized according to different types of addressing and then thecontrol unit function in which the sources are located is determined forthese sources, so that all the function calls in the entire program codemay be accomplished through function calls of the newly created hookfunction(s), so that the original function call of the control unitfunction may take place within the corresponding hook function.

Modification of the Load/Store Instructions

With the microcontroller(s) described here, there are a number ofdifferent types of addressing in a wide variety of embodiments. It ispossible to minimize this variety.

Four methods which largely cover possible combinations of a write accessto global variables are presented below. Other methods of code analysisare possible such as a relative addressing via previously occupiedaddress registers.

To do so, FIG. 3 shows an overview of the different methods formodification of the load and/or store instructions. Store instructionsst.x here mean: st.b=store byte, st.h=store half word and st.w=storeword. The four methods illustrated in FIG. 3 are explained in greaterdetail below.

Modification of the program points according to method 1 is illustratedin greater detail in FIG. 4. Method 1 involves, for example, a 16-bitstore instruction and indirect addressing. Starting from the position ofthe found store instruction, the points are traced back in thedisassembled program code until the particular load instructions aredetermined. The found load instructions are the deciding factor for thismethod. This method is used not only in problems with a mixedinstruction set but also when, for other reasons, it is impossible toreplace the store instruction with a jump instruction.

In method 1 the determined load instructions, based on the subsequentstore instruction, are replaced by address information of a pointervariable. This pointer variable is generated via a developmentenvironment, in particular the DHooks development environment. Theaddress of the pointer variable is in a reserved free area of the memorymeans, the memory layout for variables. The modified load instructionsaddress the same address register as the original instructions. Thedifference in the modified load instructions is in the type ofaddressing of the address register and the address information.

FIG. 4 illustrates method 1 in a schematic diagram showing originalprogram code 401 and modified program code 411. The control unitfunction, function_a( ) here, is formed by 402, 406 and 417, 407. Theinstructions, i.e., instruction sequences, are shown in 402 and 417,respectively, and the actual functionality is shown in 406 and 407. Thisshows access axx % to an address register (e.g., a0 through a15 in thecase of a 16-bit width) and access dxx % to a data register (e.g., d0through d15 in the case of a 16-bit width). Let us now considerinstructions movh.a and ld.a (load instructions) and st.x (storeinstruction) in 408, 409, 410, 413, 414 and 415. In this example,movh.a, ld.a and lea are shown as 32-bit instructions (see 412 and 403).Store instruction st.x is shown as a 16-bit instruction (see 405) andtherefore is not replaceable with a 32-bit jump instruction in thisexample. As stated previously, this also applies to all other cases inwhich such a replacement is impossible or undesirable. The novelinstruction code according to the present invention, i.e., program code403, is now input into 412 and the load instructions are modified topointer variable iB_PtrMsg_xxx (Ptr=pointer). The address of the controlunit variable is replaced by the address of the pointer variableaccording to 404. The method for creating additional program code, i.e.,additional functions, is explained in greater detail below according tothe four methods.

FIG. 5 shows in greater detail the modification of the program pointsaccording to method 2. The same notations and abbreviations as used inmethod 1 are also applicable here as well as in all other methodexamples. Original program code 501 and modified program code 511 areshown. The control unit function, function_a( ) here, is formed by 502,506 and 517, 507. Instructions and/or instruction sequences are shown in502 and 517, and the actual functionality is shown in 506 and 507.Access % axx to an address register (e.g., a0 through a15 in the case ofa 16-bit width) and access % dxx to a data register (e.g., d0 throughd15 in the case of a 16-bit width) are shown. Let us now considerinstructions movh.a and ld.a (load instructions) and st.x (storeinstruction). Store instruction st.x is now shown as a 32-bitinstruction (see 505) and is thus replaceable in this example by a32-bit jump instruction jla. The novel instruction code according to thepresent invention, i.e., program code 503 (jla: jump instruction), isnow input into 505.

Method 2 uses a 32-bit store instruction in conjunction with indirectaddressing. The 32-bit store instruction is replaced by an absolute jumpinstruction jla 512 to a software balcony function (balcony_M2) (seecall 520 of the software balcony function). With the jla jumpinstruction, the jump back address is stored in register all (see 521).

In software balcony function 521 mentioned above, the content of addressregister % axx by which the control unit variable is addressed, isreplaced by the address value of a pointer variable (iB_PtrMsg_xxx). Theindex of address register % axx and of the previously loaded dataregister % dxx are identical in software balcony function 521.

When 32-bit store instructions are used for the software breakpoint,additional program code is required. This program code, generated in theDHooks development environment, is referred to as a balcony function.The balcony functions include additional initializing, copying andbreakpoint mechanisms and are used as software functions to expand thebreakpoint functionality. Balcony functions are used for breakpointmethods 2, 3 and 4.

Due to jump instruction jla, the content of data register % dxx which isused remains unchanged. Addressing is then performed via the pointer inthe software balcony function and thus the store instruction is divertedto the pointer variable. Store instruction st.x writes data as in theoriginal code.

The sequence then jumps back into control unit function according to 522via the jump back address stored in address register all via an indirectjump.

FIG. 6 shows in greater detail the modification of the program pointsaccording to method 3. The same notations and abbreviations arespecifically used here as for method 2 and for all other methodexamples. Original program code 601 and modified program code 611 areshown. The control unit function, function_a( ) here, is formed by 602,607 and 617, 607. The instructions, i.e., instruction sequences, areshown in 602 and 617, respectively, and the actual functionality isshown in 606 and 607. A special st.x (store instruction), namely st.t,is considered. Store instruction st.t is now shown as a 32-bitinstruction (see 605) and thus is replaceable in this example by a32-bit function call (call balcony_M3). The instruction code accordingto the present invention, i.e., program code 603 (call: function call),is now input into 605.

In method 3 a 32-bit store instruction st.t is used in combination withdirect addressing 618 (store instruction having address 610). The 32-bitstore instruction is replaced by a 32-bit function call (callbalcony_M3, 603) of a software balcony function (balcony_M3, 621) (see604). Software balcony function 621 includes the query of a breakpointand the store instruction in the original state. When a breakpoint isactivated, no store instruction is executed. This variable is thusuncoupled from the control unit function. To do so, call 620 for balconyfunction 621 from 612 is carried out. Jump back 622 to the control unitfunction takes place via the address of the control unit variable (adr.of ecu variable) 619.

FIG. 7 shows the modification of the program points according to method4 in more detail. As is the case with all other method examples, thesame reference notations and abbreviations are used here, specificallythe same as those used for method 2. Original program code 701 andmodified program code 711 are shown. The control unit function,function_a( ) here, is formed by 702, 706 and 717, 707. Theinstructions, i.e., instruction sequences, are shown in 702 and 717,respectively, and the actual functionality is shown in 706 and 707.Access % axx to an address register and access % dxx and/or % dyy to adata register are shown. Instructions mov, st.x (store instruction) calland jla shall now be considered as described above in the methods. Storeinstruction st.x is shown as a 32-bit instruction (see 705) and is thusreplaceable in this example by a 32-bit jump instruction. The novelinstruction code according to the present invention, i.e., program code703 (jla: jump instruction), is now input into 705.

Method 4 uses a 32-bit store instruction st.x (710) in combination withdirect addressing (718). The 32-bit store instruction is replaced by a32-bit jump instruction jla (jla balcony_M4_a). The jump instructionpoints to software balcony function 1 (balcony_M4_a( ), 721) which iscalled with 720. In software balcony function 1 721, the content of thepreviously loaded data register % dxx is stored temporarily in atemporary DHook variable (iB_TmpMsg_xxx). Another balcony function(balcony_M4_b( ), 724) is called from 721 with 723 via a function“call.” This second software balcony function 2 contains the actualbreakpoint as in method 3. Software balcony function 724 contains thequery of the breakpoint. When the breakpoint is deactivated, the contentof temporary variable iB_TmpMsg_xxx is written back into the controlunit variable (see 725). When the breakpoint is active, there is norewriting. The control unit variable is thus uncoupled from the controlunit function. The jump back to the control unit function then takesplace via 722.

Modification of Function Calls (FIG. 8)

For the localized load/store sources, the control unit function in whichthe sources are located is determined. This is done using the Windowssoftware program developed for this method; on the basis of the positionof the load/store instructions and with the help of referenceinformation, it determines the corresponding beginning and end addressesof the control unit function.

Next, all function calls of the control unit function in the entireprogram code are replaced by function calls of the newly created hookfunction.

The original function call of the control unit function is performedwithin the corresponding hook function.

For reasons of simplicity, FIG. 8 uses the same diagram as that in theprevious FIGS. 2, 4, 5, 6 and 7 to make this illustration of themodification comparable. Original control unit program code 801 andmodified program code 811 are shown. A task list task_list is used and acorresponding extra function or subfunction subfunction_x( ) is used.For the sake of simplicity, there is no longer an explicitdifferentiation between instruction sequence and actual functionality(see FIGS. 3 through 7). The procedure 804 according to FIG. 2 is usedto determine the function addresses and function calls. According to805, the address of function_a is replaced by the address ofhook_function_a. Accordingly, at 806 the function call of function_a isreplaced by the call of hook_function_a. Finally, in 807, the indirectfunction call of function_a is replaced by a call of hook_function_a (asa 32-bit instruction here). The newly formed program code with thereplacements is indicated by nP.

Method for Creating Additional Program Code (FIG. 9)

For each control unit function in which there is a breakpoint, a hookfunction may thus be created and/or is created. FIG. 9 shows a schematicdiagram of such hook functions, hook_function_a( ) and hook_function_x(). Control unit program code 901 and memory area 902 for additionalprogram code are shown. Actual hook functions 903 and possibleinitialization 904 of any pointer variable needed are also shown.Program code 905 is for the software breakpoints, the configuration andtie-in of the rapid prototyping methods in particular. Finally, call 906of original control unit function function_a( ) is shown. This iscomparable for second hook function hook_function_x( ) but is not shownagain for reasons of simplicity.

The hook function thus includes the breakpoint mechanism which controlsaccess to a rapid prototyping method via application data. In addition,initialization of pointer variables and function call of the actualcontrol unit function are performed in the hook function if necessary.

Features of the hook functions are described below as a function of thebreakpoint methods.

Re breakpoint methods 1 and 2:

Before a store instruction to a control unit variable addressed by apointer may be described appropriately, the pointer variable must beaddressed using a variable address. The pointer is initialized in thehook function. If the breakpoint access is not active, the pointer isinitialized using the address of the control unit variable. If thebreakpoint access is active, the pointer is initialized using theaddress of a temporary DHooks variable. At this point, write access isdiverted to the temporary variable, e.g., in the case of indirectaddressing of the control unit variable.

Re breakpoint methods 3 and 4:

These two methods involve direct addressing of a control unit variable.No pointers which must be initialized are used here. The hook functionincludes the mechanism for controlling the software breakpoint and thefunction call of the original control unit function.

At this point, the balcony function when replaced by a jump instructionas already explained above should be mentioned briefly. This use wasexplained above in detail. If 32-bit store instructions are used for thesoftware breakpoint, then additional program code is required for thispurpose. This program code is generated in the DHooks developmentenvironment and is referred to as a balcony function. Balcony functionsinclude additional initialization, copying and breakpoint mechanisms andare used as software functions to expand the breakpoint functionality.Balcony functions are used for breakpoint methods 2, 3 and 4.

Method for Tying in the Software Breakpoint Code

The software breakpoint code is tied in by a hex code merge run, forexample. In this action, the results (hex codes) of the developmentenvironment for the dynamic breakpoint method are copied into the freeareas of the original software program (hex code). The method has astructure similar to that of the internal control unit bypass in whichhex code information from two separate software development runs islinked together.

Segmenting the Memory Areas (FIG. 10)

Dedicated memory areas of the memory means in memory layout S1 of thecontrol unit software program are needed for the breakpoint method.According to FIG. 10, the method uses free areas for code (DHook code)S4, data (DHook data) S3, and RAM (DHook-RAM) S2.

The breakpoint functions (additional program codes) are stored in thecode area, and application variables by which the breakpoint mechanismis controlled are stored in the data area. The pointer variables andadministrative RAM variables needed for the method are stored in thefree area for RAM variables.

Development Process for Creating the Program Code (FIG. 11)

The software breakpoint code is generated automatically via adevelopment environment created for the method and is illustrated againin FIG. 11. The variables in point 8 may also be selected automaticallyaccording to specifiable criteria.

-   1. Hex code file (includes the machine code, e.g., in Intel hex or    Motorola S19 format)-   2. Application data description file (includes, for example,    addresses and conversion formulas for variables and parameters)-   3. ELF binary file (linker output file having addresses of functions    and variables)-   4. Program for converting machine code into readable assembler    instructions-   5. Disassembled program code (used as input for the simulator)-   6. Converter for providing program information-   7. Reference databank (used to resolve open references)-   8. User creates selection of variables for breakpoints-   9. Information about control unit variables to be bypassed-   10. Program code simulator (reads all opcodes sequentially and    checks the register contents)-   11. Automatically generated source code (includes the program code    for the software breakpoints, additional functions and information    about the program code points to be modified)-   12. Software development environment (controls all procedures for    generating hex code and the application data)-   13. Application data for controlling the breakpoints-   14. Program code+breakpoint code+patch code-   15. Hex/A21 merge procedure (dynamic hooks components are connected    to the original program code)-   16. Application data description file (includes the project    application data and the breakpoint application data)-   17. Program version having software breakpoints

1. A method for adaptation of a function for controlling an operatingsequence of a control unit, the function accessing at least one globalvariable of at least one program for control, the method comprising:determining a breakpoint in the at least one program. wherein thedetermination is based on a comparison at least one of (1) between anaddress of the control unit and a register content loaded by a loadinstruction and (2) between the address of the control unit and adestination address of a store instruction; assigning the globalvariable address information which is present in at least one memorydevice; loading the memory device the address information of the globalvariable by at least one load instruction; and replacing the addressinformation of the global variable with one of the store instruction andthe load instruction.
 2. The method as recited in claim 1, wherein theaddress information of the global variable is replaced by addressinformation of a pointer variable.
 3. The method as recited in claim 2,wherein the address information of the pointer variable is located in areserved memory area.
 4. The method as recited in claim 1, furthercomprising: manipulating a memory instruction onto the global variableby replacing the memory instruction with a jump instruction.
 5. Themethod as recited in claim 1, further comprising: determining an initialaddress of the function from the address information.
 6. The method asrecited in claim 1, further comprising: replacing the function forcontrolling the operating sequence by replacing the address informationwith an additional function.
 7. The method as recited in claim 4,further comprising: the function for controlling the operating sequenceby replacing the memory instruction with the jump instruction isreplaced with an additional function.
 8. A device for adopting afunction for controlling an operating sequence of a control unit, thefunction accessing at least one global variable of at least one programfor control, the global variable being assigned address information, thedevice comprising: a memory in which the address information is located;a control device configured to: determine a breakpoint in the at leastone program, wherein the determination is based on a comparison at leastone of (1) between an address of the control unit and a register contentloaded by a load instruction and (2) between the address of the controlunit and a destination address of a store instruction; assign the globalvariable address information which is present in at least one memorydevice; and load the address information of the global variable out ofthe memory by at least one load instruction, the control deviceconfigured to replace the address information of the global variablewith one of the store instruction and the load instruction.
 9. Thedevice as recited in claim 8, wherein the control device replaces theaddress information of the global variable by address information of apointer variable.
 10. A control unit for controlling an operatingsequence, the control unit comprising: a device configured to adopt afunction to controlling the operating sequence of a control unit, thefunction accessing at least one global variable of at least one programfor control, the global variable being assigned address information, thedevice comprising: a memory in which the address information is located;a control device configured to: determine a breakpoint in the at leastone program, wherein the determination is based on a comparison at leastone of (1) between an address of the control unit and a register contentloaded by a load instruction and (2) between the address of the controlunit and a destination address of a store instruction; assign the globalvariable address information which is present in at least one memorydevice; and load the address information of the global variable out ofthe memory by at least one load instruction, the control deviceconfigured to replace the address information of the global variablewith one of the store instruction and the load instruction.
 11. Astorage medium storing program code executable by a computer, theprogram code, when executed by the computer causing the computer toperform the steps of: determining a breakpoint in the at least oneprogram, wherein the determination is based on a comparison at least oneof (1) between an address of the control unit and a register contentloaded by a load instruction and (2) between the address of the controlunit and a destination address of a store instruction; assigning theglobal variable address information which is present in at least onememory device; loading the address information of the global variable byat least one load instruction out of the memory device; and replacingthe address information of the global variable with one of the storeinstruction and the load instruction.
 12. A computer program havingprogram code executable by a computer, the program code, when executedby the computer causing the computer to perform the steps of:determining a breakpoint in the at least one program, wherein thedetermination is based on a comparison at least one of (1) between anaddress of the control unit and a register content loaded by a loadinstruction and (2) between the address of the control unit and adestination address of a store instruction; assigning the globalvariable address information which is present in at least one memorydevice; loading the memory device the address information of the globalvariable by at least one load; and replacing the address information ofthe global variable with one of the store instruction and the loadinstruction.
 13. A method for adapting a function to an operatingsequence for controlling a control unit of a device, the functionaccessing at least one program that includes a breakpoint, the methodcomprising: determining the breakpoint in the at least one program,wherein the determination is based on a comparison at least one of (1)between an address of the control unit and a register content loaded bya load instruction and (2) between the address of the control unit and adestination address of a store instruction; modifying at least one ofthe load instruction and the store instruction based on at least one ofa length of the load instruction, a length of the store instruction, atype of addressing, and a type of store instruction; creating a hook forthe function based on a type of the breakpoint; and tying the hook forthe function to the operating sequence.
 14. The method of claim 13,wherein the load instruction loads an address of a global variable. 15.The method of claim 13, wherein the load instruction is replaced by anaddress of a pointer variable.
 16. The method of claim 13, wherein thestore instruction is a 32-bit store instruction.
 17. The method of claim16, wherein the 32-bit store instruction is replaced by an absolute jumpinstruction.
 18. The method of claim 16, wherein the 32-bit storeinstruction is replaced by a function call.
 19. The method of claim 16,wherein the 32-bit store instruction is replaced by a 32-bit jumpinstruction.